/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Calculos;

import com.lowagie.tools.ConcatPdf;
import java.util.ArrayList;

/**
 *
 * @author Isabela
 */
public class EngastadaDistribuida {


     private ArrayList<double []> cargaDistribuida=new ArrayList<double[]>();
     private double incremento=0.005;
     private double R;
     private static final double coeficienteE = 205*Math.pow(10, 9);
     private ArrayList<double []> deformada=new ArrayList<double[]>();




    public void CalculaCargaDistribuida(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial,double IY){
        calculaReacoesApoios(forcadistribuida, comprimentocarga);
        CalculaFuncaoMomentoFletor(forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial);
        CalculaFuncaoEsforcoCortante(forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial);
        CalculaDeformada(forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial, IY);

    }

     private void calculaReacoesApoios(double forcadistribuida,double comprimentocarga){
   //Reação no apoio

    R=forcadistribuida*comprimentocarga;


   }

    private void CalculaFuncaoMomentoFletor(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){


        int tamanhoVetor=(int) (tamanhoviga / incremento);
        double y[]=new double[tamanhoVetor];
        double x[]=new double[tamanhoVetor];
        for(int i=1;i<tamanhoVetor;i++){
            x[i]=x[i-1]+incremento;
        }

        for(int i=0;i<tamanhoVetor;i++){
                if(x[i]<=(posicaoInicial)){//primeiro intervalo (x antes do inicio da carga distribuida)
                    y[i]=-1*(forcadistribuida*(((posicaoInicial+comprimentocarga)/2)-x[i]));
                }
                //entervalo que contem a carga
                else if((x[i]>=(posicaoInicial)) && (x[i]<=((posicaoInicial)+comprimentocarga))){
                    y[i]=(-1*(forcadistribuida*(Math.pow((posicaoInicial+comprimentocarga-x[i]), 2))))/2;
                }
                    // por fim quando x estiver no intervalo após a carga
                else if((x[i]>=((posicaoInicial)+comprimentocarga))){
                    y[i]=0;
                }
        }

      //  new Graficos("Gráfico Momento Fletor",x, y);// gera o gráfico
        cargaDistribuida.add(x);//adicionando  o vetor com os dados x fletor
        cargaDistribuida.add(y);//vetor com dados y fletor

    }


    private void CalculaFuncaoEsforcoCortante(double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial) {

        int tamanhoVetor = (int) (tamanhoviga / incremento);
        double y[] = new double[tamanhoVetor];
        double x[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }

        for (int i = 0; i < tamanhoVetor; i++) {
            if (x[i] <= (posicaoInicial)) {//primeiro intervalo (x antes do inicio da carga distribuida)
                y[i] = -1 * forcadistribuida;
            } //entervalo que contem a carga
            else if ((x[i] >= (posicaoInicial)) && (x[i] <= ((posicaoInicial) + comprimentocarga))) {
                y[i]=-1*(forcadistribuida*(((posicaoInicial+comprimentocarga))-x[i]));
            } // por fim quando x estiver no intervalo após a carga
            else if ((x[i] >= ((posicaoInicial) + comprimentocarga))) {
                y[i] = 0;
            }
        }

         cargaDistribuida.add(x);
         cargaDistribuida.add(y);

    }


     public  double CalculaMomentoFletorNoPonto(double x,double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial){
         double resultado=0.0;

          if(x<=(posicaoInicial)){//primeiro intervalo (x antes do inicio da carga distribuida)
                    resultado=-1*(forcadistribuida*(((posicaoInicial+comprimentocarga)/2)-x));
                }
                //entervalo que contem a carga
                else if((x>=(posicaoInicial)) && (x<=((posicaoInicial)+comprimentocarga))){
                    resultado=(-1*(forcadistribuida*(Math.pow((posicaoInicial+comprimentocarga-x), 2))))/2;
                }
                    // por fim quando x estiver no intervalo após a carga
                else if((x>=((posicaoInicial)+comprimentocarga))){
                    resultado=0;
        
     }
          return resultado;
    }

     public double CalculaDeformadaNoPonto(double x,double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial, double IY) {
        double resultado = 0.0;
        double q=forcadistribuida;
        double L=tamanhoviga;
        double a=comprimentocarga;

            if(x<=a){
                resultado=q*Math.pow(x, 2)*((6*Math.pow(a, 2)) - (4*a*x) + Math.pow(x, 2));
            }
            
            else if(x>=a){
                resultado=q*Math.pow(a, 3)*(4*x - a);
            }
            
           resultado/=24*coeficienteE*IY;
        return resultado;
    }

     public void CalculaDeformada(double forcadistribuida, double comprimentocarga, double tamanhoviga, double posicaoInicial, double IY) {
        double resultado = 0.0;

        int tamanhoVetor = (int) (tamanhoviga / incremento);
        double y[] = new double[tamanhoVetor];
        double x[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }

        for (int i = 0; i < tamanhoVetor; i++) {
            
          y[i]=CalculaDeformadaNoPonto(x[i], forcadistribuida, comprimentocarga, tamanhoviga, posicaoInicial, IY);

        }

        deformada.add(x);
        deformada.add(y);

    }

    public double CalculaEsforcoCortanteNoPonto(double x,double forcadistribuida, double comprimentocarga,
            double tamanhoviga, double posicaoInicial) {


                double resultado = 0;

            if (x <= (posicaoInicial)) {//primeiro intervalo (x antes do inicio da carga distribuida)
                resultado = -1 * forcadistribuida;
            } //entervalo que contem a carga
            else if ((x >= (posicaoInicial)) && (x <= ((posicaoInicial) + comprimentocarga))) {
                resultado=-1*(forcadistribuida*(((posicaoInicial+comprimentocarga))-x));
            } // por fim quando x estiver no intervalo após a carga
            else if ((x >= ((posicaoInicial) + comprimentocarga))) {
                resultado = 0;
            }
                return resultado;
        }

    private void CalculaFuncaoDeformada(double forcadistribuida,double comprimentocarga,double tamanhoviga,double posicaoInicial, double IY){


        int tamanhoVetor=(int) (tamanhoviga / incremento);
        double y[]=new double[tamanhoVetor];
        double x[]=new double[tamanhoVetor];
        for(int i=1;i<tamanhoVetor;i++){
            x[i]=x[i-1]+incremento;
        }

        for(int i=0;i<tamanhoVetor;i++){
                if(x[i]<=(posicaoInicial)){//primeiro intervalo (x antes do inicio da carga distribuida)
                    y[i]= ((forcadistribuida*Math.pow(x[i], 2)) / 12*coeficienteE*IY) * (3*comprimentocarga*tamanhoviga + 3*posicaoInicial
                            *comprimentocarga - 2*comprimentocarga*x[i]);
                }
                //entervalo que contem a carga
                else if((x[i]>=(posicaoInicial)) && (x[i]<=((posicaoInicial)+comprimentocarga))){
                    y[i]=((forcadistribuida) / 24*coeficienteE*IY) * (Math.pow(x[i], 4) - 4*tamanhoviga*Math.pow(x[i], 3) +
                            6*Math.pow(tamanhoviga, 2)*Math.pow(x[i], 2) - 4*Math.pow(posicaoInicial, 3)*x[i] + Math.pow(posicaoInicial, 4));
                }
                    // por fim quando x estiver no intervalo após a carga
                else if((x[i] == posicaoInicial)){
                    y[i]= ((forcadistribuida*Math.pow(posicaoInicial, 2)*comprimentocarga) / 12*coeficienteE*IY) * (3*tamanhoviga + posicaoInicial);
                }
        }

      //  new Graficos("Gráfico Momento Fletor",x, y);// gera o gráfico
        deformada.add(x);//adicionando  o vetor com os dados x fletor
        deformada.add(y);//vetor com dados y fletor

    }




    public ArrayList<double[]> getCargaDistribuida() {
        return cargaDistribuida;
    }

    public double getR() {
        return R;
    }

    public ArrayList<double[]> getDeformada() {
        return deformada;
    }

    


}
